home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / langs / sozo2 / scsrc20.lzh / JAS.LZH / LEX.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-02-22  |  8.0 KB  |  336 lines
  1.  
  2. /*
  3.  * Copyright (c) 1988,1991 by Sozobon, Limited.  Author: Joseph M Treat
  4.  *
  5.  * Permission is granted to anyone to use this software for any purpose
  6.  * on any computer system, and to redistribute it freely, with the
  7.  * following restrictions:
  8.  * 1) No charge may be made other than reasonable charges for reproduction.
  9.  * 2) Modified versions must be clearly marked as such.
  10.  * 3) The authors are not responsible for any harmful consequences
  11.  *    of using this software, even if they result from defects in it.
  12.  */
  13.  
  14. #include "jas.h"
  15. #include "scan.h"
  16. #include "parse.h"
  17.  
  18. extern do_star;
  19.  
  20. struct reserved words[] = {
  21.     /*
  22.      * alphabetized list of reserved words
  23.      */
  24. #ifdef MINIX
  25.     { ".align",    _ALIGN,        0 },
  26.     { ".ascii",    _DC,        8 },
  27.     { ".asciz",    _ASCII,        0 },
  28. #endif
  29.     { ".bss",    _BSS,        0 },
  30.     { ".comm",    _COMM,        0 },
  31.     { ".data",    _DATA,        0 },
  32. #ifdef MINIX
  33.     { ".data1",    _DC,        8 },
  34.     { ".data2",    _DC,        16 },
  35.     { ".data4",    _DC,        32 },
  36. #endif
  37.     { ".dc",    _DC,        0 },
  38. #ifdef MINIX
  39.     { ".define",    _GLOBL,        0 },
  40. #endif
  41.     { ".ds",    _DS,        0 },
  42.     { ".end",    END,        0 },
  43.     { ".equ",    _EQU,        0 },
  44.     { ".even",    _EVEN,        0 },
  45. #ifdef MINIX
  46.     { ".extern",    _GLOBL,        0 },
  47. #endif
  48.     { ".globl",    _GLOBL,        0 },
  49.     { ".org",    _ORG,        0 },
  50. #ifdef MINIX
  51.     { ".rom",    _DATA,        0 },
  52.     { ".sect",    _SECT,        0 },
  53.     { ".space",    _DS,        8 },
  54. #endif
  55.     { ".text",    _TEXT,        0 },
  56.     { "a0",        REG,        8 },
  57.     { "a1",        REG,        9 },
  58.     { "a2",        REG,        10 },
  59.     { "a3",        REG,        11 },
  60.     { "a4",        REG,        12 },
  61.     { "a5",        REG,        13 },
  62.     { "a6",        REG,        14 },
  63.     { "a7",        REG,        15 },
  64.     { "bss",    _BSS,        0 },
  65.     { "ccr",    SREG,        O_CCR },
  66.     { "comm",    _COMM,        0 },
  67.     { "d0",        REG,        0 },
  68.     { "d1",        REG,        1 },
  69.     { "d2",        REG,        2 },
  70.     { "d3",        REG,        3 },
  71.     { "d4",        REG,        4 },
  72.     { "d5",        REG,        5 },
  73.     { "d6",        REG,        6 },
  74.     { "d7",        REG,        7 },
  75.     { "data",    _DATA,        0 },
  76.     { "dc",        _DC,        0 },
  77.     { "ds",        _DS,        0 },
  78.     { "end",    END,        0 },
  79.     { "equ",    _EQU,        0 },
  80.     { "even",    _EVEN,        0 },
  81.     { "globl",    _GLOBL,        0 },
  82.     { "org",    _ORG,        0 },
  83.     { "pc",        PC,        0 },
  84.     { "sp",     REG,        15 },
  85.     { "sr",        SREG,        O_SR },
  86.     { "text",    _TEXT,        0 },
  87.     { "usp",    SREG,        O_USP },
  88.     { "", 0, 0 }
  89. };
  90.  
  91. int nwords = (sizeof words) / (sizeof (struct reserved));
  92.  
  93. struct lexacts actions[256];
  94.  
  95. struct lextab lextab[] = {
  96. #ifdef MINIX
  97.     { '=', { L_TOKEN, _EQU } },
  98. #endif
  99.     { '\t', { L_SKIP, 0 } },
  100.     { '\n', { L_TOKEN, NL } },
  101.     { '\r', { L_SKIP, 0 } },
  102.     { ' ', { L_SKIP, 0 } },
  103.     { '"', { L_EXTRA|L_TOKEN, ERR } },
  104.     { '\'', { L_EXTRA|L_TOKEN, ERR } },
  105.     { '%', { L_TOKEN, MOD } },
  106.     { '(', { L_TOKEN, LP } },
  107.     { ')', { L_TOKEN, RP } },
  108.     { '*', { L_TOKEN, STAR } },
  109.     { '-', { L_TOKEN, MINUS } },
  110.     { '+', { L_TOKEN, PLUS } },
  111.     { ',', { L_TOKEN, COMMA } },
  112.     { '/', { L_EXTRA|L_TOKEN, DIV } },
  113.     { '~', { L_EXTRA|L_TOKEN, NOT } },
  114.     { '#', { L_TOKEN, POUND } },
  115.     { '@', { L_EXTRA|L_DIGIT, NUMBER } },
  116.     { '$', { L_EXTRA|L_DIGIT, NUMBER } },
  117.     { '0', { L_MIDID|L_DIGIT, NUMBER } },
  118.     { '1', { L_MIDID|L_DIGIT, NUMBER } },
  119.     { '2', { L_MIDID|L_DIGIT, NUMBER } },
  120.     { '3', { L_MIDID|L_DIGIT, NUMBER } },
  121.     { '4', { L_MIDID|L_DIGIT, NUMBER } },
  122.     { '5', { L_MIDID|L_DIGIT, NUMBER } },
  123.     { '6', { L_MIDID|L_DIGIT, NUMBER } },
  124.     { '7', { L_MIDID|L_DIGIT, NUMBER } },
  125.     { '8', { L_MIDID|L_DIGIT, NUMBER } },
  126.     { '9', { L_MIDID|L_DIGIT, NUMBER } },
  127.     { ':', { L_TOKEN, COLON } },
  128.     { ';', { L_TOKEN|L_EXTRA, COMMENT } },
  129. #ifdef MINIX
  130.     { '!', { L_TOKEN|L_EXTRA, COMMENT } },
  131. #endif
  132.     { '<', { L_EXTRA|L_TOKEN, ERR } },
  133.     { '>', { L_EXTRA|L_TOKEN, ERR } },
  134.     { 'A', { L_BEGID|L_MIDID|L_DIGIT, NAME } },
  135.     { 'B', { L_BEGID|L_MIDID|L_DIGIT, NAME } },
  136.     { 'C', { L_BEGID|L_MIDID|L_DIGIT, NAME } },
  137.     { 'D', { L_BEGID|L_MIDID|L_DIGIT, NAME } },
  138.     { 'E', { L_BEGID|L_MIDID|L_DIGIT, NAME } },
  139.     { 'F', { L_BEGID|L_MIDID|L_DIGIT, NAME } },
  140.     { 'G', { L_BEGID|L_MIDID, NAME } },
  141.     { 'H', { L_BEGID|L_MIDID, NAME } },
  142.     { 'I', { L_BEGID|L_MIDID, NAME } },
  143.     { 'J', { L_BEGID|L_MIDID, NAME } },
  144.     { 'K', { L_BEGID|L_MIDID, NAME } },
  145.     { 'L', { L_BEGID|L_MIDID, NAME } },
  146.     { 'M', { L_BEGID|L_MIDID, NAME } },
  147.     { 'N', { L_BEGID|L_MIDID, NAME } },
  148.     { 'O', { L_BEGID|L_MIDID, NAME } },
  149.     { 'P', { L_BEGID|L_MIDID, NAME } },
  150.     { 'Q', { L_BEGID|L_MIDID, NAME } },
  151.     { 'R', { L_BEGID|L_MIDID, NAME } },
  152.     { 'S', { L_BEGID|L_MIDID, NAME } },
  153.     { 'T', { L_BEGID|L_MIDID, NAME } },
  154.     { 'U', { L_BEGID|L_MIDID, NAME } },
  155.     { 'V', { L_BEGID|L_MIDID, NAME } },
  156.     { 'W', { L_BEGID|L_MIDID, NAME } },
  157.     { 'X', { L_BEGID|L_MIDID, NAME } },
  158.     { 'Y', { L_BEGID|L_MIDID, NAME } },
  159.     { 'Z', { L_BEGID|L_MIDID, NAME } },
  160.     { '.', { L_BEGID|L_MIDID, NAME } },
  161.     { '_', { L_BEGID|L_MIDID, NAME } },
  162.     { 'a', { L_BEGID|L_MIDID|L_DIGIT, NAME } },
  163.     { 'b', { L_BEGID|L_MIDID|L_DIGIT, NAME } },
  164.     { 'c', { L_BEGID|L_MIDID|L_DIGIT, NAME } },
  165.     { 'd', { L_BEGID|L_MIDID|L_DIGIT, NAME } },
  166.     { 'e', { L_BEGID|L_MIDID|L_DIGIT, NAME } },
  167.     { 'f', { L_BEGID|L_MIDID|L_DIGIT, NAME } },
  168.     { 'g', { L_BEGID|L_MIDID, NAME } },
  169.     { 'h', { L_BEGID|L_MIDID, NAME } },
  170.     { 'i', { L_BEGID|L_MIDID, NAME } },
  171.     { 'j', { L_BEGID|L_MIDID, NAME } },
  172.     { 'k', { L_BEGID|L_MIDID, NAME } },
  173.     { 'l', { L_BEGID|L_MIDID, NAME } },
  174.     { 'm', { L_BEGID|L_MIDID, NAME } },
  175.     { 'n', { L_BEGID|L_MIDID, NAME } },
  176.     { 'o', { L_BEGID|L_MIDID, NAME } },
  177.     { 'p', { L_BEGID|L_MIDID, NAME } },
  178.     { 'q', { L_BEGID|L_MIDID, NAME } },
  179.     { 'r', { L_BEGID|L_MIDID, NAME } },
  180.     { 's', { L_BEGID|L_MIDID, NAME } },
  181.     { 't', { L_BEGID|L_MIDID, NAME } },
  182.     { 'u', { L_BEGID|L_MIDID, NAME } },
  183.     { 'v', { L_BEGID|L_MIDID, NAME } },
  184.     { 'w', { L_BEGID|L_MIDID, NAME } },
  185. #ifdef MINIX
  186.     { 'x', { L_BEGID|L_MIDID|L_DIGIT, NAME } },
  187. #else
  188.     { 'x', { L_BEGID|L_MIDID, NAME } },
  189. #endif
  190.     { 'y', { L_BEGID|L_MIDID, NAME } },
  191.     { 'z', { L_BEGID|L_MIDID, NAME } }
  192. };
  193.  
  194. struct lexacts deflexact = { L_TOKEN, ERR };
  195.  
  196. static int lextabsize = (sizeof lextab) / (sizeof (struct lextab));
  197.  
  198. yyinit()
  199. {
  200.     {
  201.         register struct lexacts *ap;
  202.         
  203.         for ( ap = actions; ap < &actions[256]; ap++ )
  204.             *ap = deflexact;
  205.     }
  206.     {
  207.         register struct lextab *lp;
  208.         register struct lextab *ep;
  209.         
  210.         ep = &lextab[lextabsize];
  211.         for ( lp = lextab; lp < ep; lp++ )
  212.             actions[lp->select] = lp->action;
  213.     }
  214. }
  215.  
  216. yyprocess( c )
  217.     register char c;
  218. {
  219.     register int i;
  220.     char buf[256];
  221.     extern YYSTYPE yylval;
  222.     extern int line;
  223.  
  224.     switch ( c ) {
  225.     case '/':
  226.         c = yygetc();
  227.         if ( c != '*' ) {
  228.             yyungetc( c );
  229.             return 0;
  230.         }
  231.         do_star = 0;
  232.         for ( c = yygetc(); c; c = yygetc()) {
  233.             if ( c == '\n' ) {
  234.                 line++;
  235.             } else {
  236.                 if ( c == '*' ) {
  237.                     c = yygetc();
  238.                     if ( c == '/' ) {
  239.                         do_star = 1;
  240.                         return COMMENT;
  241.                     }
  242.                     yyungetc( c );
  243.                 }
  244.             }
  245.         }
  246.         error( line, "non-terminated comment");
  247.  
  248.     case '\'':
  249.         do_star = 0;
  250.         c = yygetc();
  251.         for ( i = 0; c; ) {
  252.             buf[i++] = c;
  253.             if ( c == '\\' ) 
  254.                 buf[i++] = yygetc();
  255.             c = yygetc();
  256.             if ( c == '\'' )
  257.                 break;
  258.         }
  259.         if (! c )
  260.             error( line, "non-terminated string" );
  261.         buf[i] = '\0';
  262.         yylval.str = STRCPY( buf );
  263.         do_star = 1;
  264.         return STRING;
  265.     case '"':
  266.         do_star = 0;
  267.         c = yygetc();
  268.         for (i = 0; c; ) {
  269.             buf[i++] = c;
  270.             if ( c == '\\' )
  271.                 buf[i++] = yygetc();
  272.             c = yygetc();
  273.             if ( c == '"' )
  274.                 break;
  275.         }
  276.         if (! c )
  277.             error( line, "non-terminated string" );
  278.         buf[i] = '\0';
  279.         yylval.str = STRCPY( buf );
  280.         do_star = 1;
  281.         return STRING;
  282.     case '<':
  283.         c = yygetc();
  284.         if ( c == '<' )
  285.             return LSH;
  286.         yyungetc( c );
  287.         return 0;
  288.     case '>':
  289.         c = yygetc();
  290.         if ( c == '>' )
  291.             return RSH;
  292.         yyungetc( c );
  293.         return 0;
  294.     case '@':
  295.         c = yygetc();
  296.         if ( c >= '0' && c <= '7' ) {
  297.             yyungetc( c );
  298.             return 0;
  299.         }
  300.         return ERR;
  301.     case '$':
  302.         c = yygetc();
  303.         if ( c >= '0' && c <= '9' ||
  304.                 c >= 'a' && c <= 'f' ||
  305.                         c >= 'A' && c <= 'F' ) {
  306.             yyungetc( c );
  307.             return 0;
  308.         }
  309.         return ERR;
  310. #ifdef MINIX
  311.     case '!':
  312. #endif
  313.     case ';':
  314.         do_star = 0;
  315.         do {
  316.             c = yygetc();
  317.         } while ( c && c != '\n' );
  318.         if ( c )
  319.             yyungetc( c );
  320.         do_star = 1;
  321.         return COMMENT;
  322.     default:
  323.         return 0;
  324.     }
  325. }
  326.  
  327. yymodify( buf )
  328.     char *buf;
  329. {
  330.     register char *cp;
  331.  
  332.     for ( cp = buf; *cp; cp++ )
  333.         if ( isupper( *cp ) )
  334.             *cp = toupper( *cp );
  335. }
  336.